#!/usr/bin/env python

import gtk.glade
import gtk
import gtk.gdk
import gobject
from config import *
from documents import *
    
class gladeInterfase:
    glade_xml = gtk.glade.XML(FILE_GLADE)
        
    def __init__(self):
        pass 
        
    def get_widget(self, widget_name):
        return self.glade_xml.get_widget(widget_name)
    
    def autoconnect(self):
        self.glade_xml.signal_autoconnect(self)


class gtkWindow(gladeInterfase):
    def __init__(self):
        self.window = self.get_widget("window")
        self.set_icon()
        self.combo = self.get_widget("combo_menu")
        self.create_menu()
        self.btn_eliminar = self.get_widget("btn_eliminar")   
        self.status_bar = self.get_widget("status_bar")
        self.notebook = self.get_widget("notebook")
        self.autoconnect()
    
    def set_icon(self):
        icon = gtk.gdk.pixbuf_new_from_file(DIR_IMAGES + "minicontactos.png")
        self.window.set_icon(icon)
      
    def create_menu(self):
        " Crea el menu para seleccionar contactos o cuentas"
        
        iconos = {"contactos":"contactos.png",
                        "cuentas": "cuentas.png"}
    
        model = gtk.ListStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING)
        self.combo.set_model(model) 
           
        icon = gtk.CellRendererPixbuf()
        self.combo.pack_start(icon, False)
        self.combo.set_attributes(icon, pixbuf=0)

        name = gtk.CellRendererText()
        self.combo.pack_start(name, True)
        self.combo.set_attributes(name, text=1)    

        pix1 = gtk.gdk.pixbuf_new_from_file(DIR_IMAGES + iconos["contactos"])
        pix2 = gtk.gdk.pixbuf_new_from_file(DIR_IMAGES + iconos["cuentas"])
        
        model.append([pix1, "Contactos"])
        model.append([pix2, "Cuentas"])

        self.combo.set_active(0)

    def on_combo_menu_changed(self, *args):
        page = self.combo.get_active()
        if page == 0: main.selected = 'contactos'
        elif page == 1: main.selected = 'cuentas'
        self.notebook.set_current_page(page)        
            
    def on_window_delete_event(*args):
        gtk.main_quit()
    
    def on_btn_nuevo_clicked(*args):
        if main.selected == 'contactos':
            dialog = gtkDialogContacto("Contacto(Nuevo)")
            contacto = dialog.create_contacto()
            if contacto: main.lista_contactos.new(contacto)
        elif main.selected == 'cuentas':
            dialog = gtkDialogCuenta("Cuenta(Nueva)")
            cuenta = dialog.create_cuenta()
            if cuenta: main.lista_cuentas.new(cuenta)
                
    def on_btn_eliminar_clicked(self, *args):
        if main.selected == 'contactos':
            main.lista_contactos.question_if_remove()
        elif main.selected == 'cuentas':
            main.lista_cuentas.question_if_remove()
            
    def on_exportar_contactos_html_activate(*args):
        html = main.libreta.to_html()
        file = gtkDialogSaveFile(title = "Exportar como Html", 
                                 suggested_name = "contactos.html")
        if file:
            try:
                f = open(file, "w")
                f.write(html)
            except:
                msg = "No se pudo guardar el archivo %s" % file
                dialog = gtk.MessageDialog(message_format = msg, 
                                           buttons= gtk.BUTTONS_CLOSE,
                                           type=gtk.MESSAGE_ERROR)
                dialog.run()
                dialog.destroy()

    def on_exportar_contactos_xml_activate(*args):
        xml = main.libreta.to_xml()
        file = gtkDialogSaveFile(title = 'Exportar como Xml',
                                 suggested_name= 'contactos.xml')

        if file:
            try:
                f = open(file, "w")
                f.write(xml)
            except:
                msg = "No se pudo guardar el archivo %s" % file
                dialog = gtk.MessageDialog(message_format = msg, 
                                           buttons= gtk.BUTTONS_CLOSE,
                                           type=gtk.MESSAGE_ERROR)
                dialog.run()
                dialog.destroy()


    def on_acerca_de_activate(self, *args):
        dialogabout =  self.get_widget("aboutdialog")
        dialogabout.run()
        
    def on_salir_activate(*args):
        gtk.main_quit()

class gtkDialogContacto:
    def __init__(self, title="Contacto"):
        xml = gtk.glade.XML(FILE_GLADE, "dialog_contacto")
        
        self.dialog = xml.get_widget("dialog_contacto")
        self.dialog.set_transient_for(main.window.window)
        self.dialog.set_title(title)

        self.combomeses = xml.get_widget("combo_meses")
        self.set_meses()
        self.nombre = xml.get_widget("entry_nombre")
        self.celular = xml.get_widget("entry_celular")
        self.telefono = xml.get_widget("entry_telefono")
        self.email = xml.get_widget("entry_email")
        self.msn = xml.get_widget("entry_msn")
        self.direccion = xml.get_widget("entry_direccion")
        self.dia = xml.get_widget("entry_dia")
        self.nota = xml.get_widget("entry_nota")
        
    def create_contacto(self):
        newcontacto = None
        response = self.dialog.run()
        self.dialog.destroy()
        if response == gtk.RESPONSE_OK:
            newcontacto = self.get_form()
            # Agrego el nuevo contacto
            newcontacto.node = main.libreta.append(newcontacto)
        return newcontacto
    
    def edit_contacto(self, oldcontacto):
        self.set_form(oldcontacto)
        response = self.dialog.run()
        
        newcontacto = None
        if response == gtk.RESPONSE_OK:
            newcontacto = self.get_form()
            # Agrego el nuevo contacto y elimino el antiguo
            newcontacto.node = main.libreta.append(newcontacto)
            main.libreta.remove(oldcontacto)            
        self.dialog.destroy()       
        return newcontacto 
    
    def set_form(self, contacto):
        self.nombre.set_text(contacto.nombre)
        self.celular.set_text(contacto.celular)
        self.telefono.set_text(contacto.telefono)
        self.email.set_text(contacto.email)
        self.msn.set_text(contacto.msn)
        self.direccion.set_text(contacto.direccion)
        # Set nota TextView
        buffer = self.nota.get_buffer()
        buffer.set_text(contacto.nota)

        self.dia.set_text(contacto.get_dia_cumpleanios())
        self.combomeses.set_active(contacto.get_mes_cumpleanios())

    def get_form(self):
        contacto = Contacto()

        contacto.nombre = self.nombre.get_text()
        contacto.celular = self.celular.get_text()
        contacto.telefono = self.telefono.get_text()
        contacto.email = self.email.get_text()
        contacto.msn = self.msn.get_text()
        contacto.direccion = self.direccion.get_text()

        # Get Nota from textview
        buffer = self.nota.get_buffer()
        contacto.nota = buffer.get_text(buffer.get_start_iter(), 
                                        buffer.get_end_iter())
        # Get dia and mes del cumpleanios
        dia = self.dia.get_text()
        mes = self.combomeses.get_active()
        contacto.cumpleanios = self.mkfecha(dia, mes)

        return contacto
        
    def mkfecha(self, dia, mes):
        fecha = ""
        if dia.isdigit() and int(dia) > 0 and int(dia) < 31:  
            if mes > 0:
                fecha = dia + "/" + str(mes)
        return fecha
        
    def set_meses(self):
        MesesList = ["Enero", "Febrero", "Marzo", "Abril", "Mayo",
                     "Junio", "Julio", "Agosto", "Septiembre", "Octubre",
                     "Noviembre","Diciembre"]

        meses_title = "Mes"
        liststore = gtk.ListStore(gobject.TYPE_STRING)
        MesesList.insert(0, meses_title)
        
        for mes in MesesList:
            liststore.set_value(liststore.append(), 0, mes)
        self.combomeses.set_model(liststore)
        
        self.combomeses.set_active(0)

        cell = gtk.CellRendererText()
        self.combomeses.pack_start(cell, True)
        self.combomeses.add_attribute(cell, 'text', 0)


class gtkListaContactos(gladeInterfase):
    
    MyName = "lista_contactos"
    (COL_OBJECT,
     COL_PIXBUF,
     COL_NOMBRE, 
     COL_CELULAR,
     COL_TELEFONO,
     COL_EMAIL,
     COL_MSN,
     COL_DIRECCION) = range(8)

    def __init__(self):
        self.tree = self.get_widget(self.MyName)
        self.model = self.create_model()
        self.tree.set_model(self.model)
        self.add_columns()
        self.tree.columns_autosize()

        # Creamos el icono del contactos solo una vez
        self.icon = gtk.gdk.pixbuf_new_from_file(DIR_IMAGES + "minicontactos.png")
        self.autoconnect()
        
    def create_model(self):    
        model = gtk.ListStore(gobject.TYPE_PYOBJECT,
                              gtk.gdk.Pixbuf, 
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING)
        return model                                       
                                               
    def add_columns(self):
     
        # Columna Nombre (texto e icono)
        render_pixbuf = gtk.CellRendererPixbuf()
        render_text = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Nombre") 
        column.pack_start(render_pixbuf, False)
        column.pack_start(render_text, False)
        column.set_attributes(render_pixbuf, pixbuf=self.COL_PIXBUF)
        column.set_attributes(render_text, text=self.COL_NOMBRE)
        column.set_resizable(True)
        column.set_expand(True)    
        column.set_sort_column_id(self.COL_NOMBRE)
        self.tree.append_column(column)
        
        # Celular
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Celular", 
                                    renderer,
                                    text=self.COL_CELULAR)
        column.set_resizable(True)
        self.tree.append_column(column)
        
        # Telefono 
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Telefono", 
                                    renderer,
                                    text=self.COL_TELEFONO)
        column.set_resizable(True)
        self.tree.append_column(column)

        # Email
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Email", 
                                    renderer,
                                    text=self.COL_EMAIL)
        column.set_resizable(True)
        self.tree.append_column(column)
        
        # Msn
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("MSN", 
                                    renderer,
                                    text=self.COL_MSN)
        column.set_resizable(True)
        self.tree.append_column(column)
        
        # Direccion
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Direccion", 
                                    renderer,
                                    text=self.COL_DIRECCION)
        column.set_resizable(True)
        self.tree.append_column(column)       

                
    def append(self, contacto):
        self.model.append([contacto, 
                           self.icon, contacto.nombre, contacto.celular, 
                           contacto.telefono, contacto.email,
                           contacto.msn, contacto.direccion])
    
    def new(self, contacto):
        self.append(contacto)
        main.statusbar.set_message("Contacto '%s' agregado" % contacto.nombre)
        
    def populate(self, items=None):
        self.clear()
        if items == None:
            items = main.libreta.get()
        for contacto in items:
            self.append(contacto)

    def clear(self):
        self.model.clear()

    def remove(self, _iter):
        contacto = self.model.get_value(_iter, self.COL_OBJECT)
        main.libreta.remove(contacto)
        self.model.remove(_iter)
        main.statusbar.set_message("Contacto '%s' eliminado" % contacto.nombre)
        
    def question_if_remove(self):
        _iter = self.get_row_selected()
        if _iter:
            nombre = self.model.get_value(_iter, self.COL_NOMBRE)
            msg = "Esta seguro que quiere eliminar a %s?" % nombre
            dialog = gtk.MessageDialog(message_format = msg, 
                                                    buttons= gtk.BUTTONS_YES_NO)
            response = dialog.run()
            dialog.destroy()
            if response == gtk.RESPONSE_YES:
                self.remove(_iter)       
        else:
            error = "Debe seleccionar un Contacto"
            dialog = gtk.MessageDialog(message_format = error, 
                                            type = gtk.MESSAGE_WARNING)
            dialog.run()
            dialog.destroy()

    def update(self, _iter, contacto):
        self.model.set(_iter,
                       self.COL_OBJECT, contacto,
                       self.COL_NOMBRE, contacto.nombre, 
                       self.COL_CELULAR, contacto.celular,
                       self.COL_TELEFONO, contacto.telefono,
                       self.COL_EMAIL, contacto.email,
                       self.COL_MSN, contacto.msn,
                       self.COL_DIRECCION, contacto.direccion)
        main.statusbar.set_message("Contacto '%s' modificado" % contacto.nombre)


    def get_row_selected(self):
        selection = self.tree.get_selection() 
        _iter = selection.get_selected()[1]
        return _iter

    def get_contacto(self, _iter):
        contacto = self.model.get_value(_iter, self.COL_OBJECT)
        return contacto
        
    def on_lista_contactos_row_activated(self, tree, path, column):
        _iter = self.model.get_iter(path)
        contacto = self.get_contacto(_iter)

        dialog = gtkDialogContacto("Contacto(%s)" % contacto.nombre)
        contacto = dialog.edit_contacto(contacto)
        # Al editar un contacto se crea uno nuevo y se elimina el antiguo
        if contacto:
            self.update(_iter, contacto)
            
    def on_lista_contactos_button_press_event(self,  widget, event):
        if event.button == 3:
            gtkMenuContextual(event)


class gtkListaCuentas(gladeInterfase):
    
    MyName = "lista_cuentas"
    (COL_OBJECT,
     COL_PIXBUF,
     COL_NOMBRE, 
     COL_LUGAR,
     COL_USUARIO,
     COL_EMAIL,
     COL_CLAVE,
     COL_DESCRIPCION
     ) = range(8)
     
    def __init__(self):
        self.tree = self.get_widget(self.MyName)
        self.model = self.create_model()
        self.tree.set_model(self.model)
        self.add_columns()
        self.tree.columns_autosize()

        # Creamos el icono de la cuenta
        self.icon = gtk.gdk.pixbuf_new_from_file(DIR_IMAGES + "minicuentas.png")
        self.autoconnect()
        
    def create_model(self):    
        model = gtk.ListStore(gobject.TYPE_PYOBJECT,
                              gtk.gdk.Pixbuf, 
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING,
                              gobject.TYPE_STRING
                              )
        return model                                       
                                               
    def add_columns(self):
     
        # Columna Nombre (texto e icono)
        render_pixbuf = gtk.CellRendererPixbuf()
        render_text = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Nombre") 
        column.pack_start(render_pixbuf, False)
        column.pack_start(render_text, False)
        column.set_attributes(render_pixbuf, pixbuf=self.COL_PIXBUF)
        column.set_attributes(render_text, text=self.COL_NOMBRE)
        column.set_resizable(True)
        column.set_expand(True)    
        column.set_sort_column_id(self.COL_NOMBRE)
        self.tree.append_column(column)
        
        # Lugar
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Lugar", 
                                    renderer,
                                    text=self.COL_LUGAR)
        column.set_resizable(True)
        self.tree.append_column(column)
        
        # Usuario
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Usuario", 
                                    renderer,
                                    text=self.COL_USUARIO)
        column.set_resizable(True)
        self.tree.append_column(column)
        
        # Email
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Email", 
                                    renderer,
                                    text=self.COL_EMAIL)
        column.set_resizable(True)
        self.tree.append_column(column)
        
        # Clave 
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Clave", 
                                    renderer,
                                    text=self.COL_CLAVE)
        column.set_resizable(True)
        self.tree.append_column(column)

        # Descripcion
        renderer = gtk.CellRendererText()
        column = gtk.TreeViewColumn("Descripcion", 
                                    renderer,
                                    text=self.COL_DESCRIPCION)
        column.set_resizable(True)
        self.tree.append_column(column)
                
    def append(self, cuenta):
        self.model.append([cuenta, 
                           self.icon, cuenta.nombre, cuenta.usuario, cuenta.email, cuenta.lugar, 
                           cuenta.clave, cuenta.descripcion])
    
    def new(self, cuenta):
        self.append(cuenta)
        main.statusbar.set_message("Cuenta '%s' agregado" % cuenta.nombre)
        
    def populate(self, items=None):
        self.clear()
        if items == None:
            items = main.cuentas.get()
        for cuenta in items:
            self.append(cuenta)

    def clear(self):
        self.model.clear()

    def remove(self, _iter):
        cuenta = self.model.get_value(_iter, self.COL_OBJECT)
        main.cuentas.remove(cuenta)
        self.model.remove(_iter)
        main.statusbar.set_message("Cuenta '%s' eliminado" % cuenta.nombre)
        
    def question_if_remove(self):
        _iter = self.get_row_selected()
        if _iter:
            nombre = self.model.get_value(_iter, self.COL_NOMBRE)
            msg = "Esta seguro que quiere eliminar %s?" % nombre
            dialog = gtk.MessageDialog(message_format = msg, 
                                                    buttons= gtk.BUTTONS_YES_NO)
            response = dialog.run()
            dialog.destroy()
            if response == gtk.RESPONSE_YES:
                self.remove(_iter)       
        else:
            error = "Debe seleccionar una Cuenta"
            dialog = gtk.MessageDialog(message_format = error, 
                                            type = gtk.MESSAGE_WARNING)
            dialog.run()
            dialog.destroy()

    def update(self, _iter, cuenta):
        self.model.set(_iter,
                       self.COL_OBJECT, cuenta,
                       self.COL_NOMBRE, cuenta.nombre,
                       self.COL_USUARIO, cuenta.usuario,
                       self.COL_EMAIL, cuenta.email, 
                       self.COL_LUGAR, cuenta.lugar,
                       self.COL_CLAVE, cuenta.clave,
                       self.COL_DESCRIPCION, cuenta.descripcion
                       )
        main.statusbar.set_message("Cuenta '%s' modificado" % cuenta.nombre)

    def get_row_selected(self):
        selection = self.tree.get_selection() 
        _iter = selection.get_selected()[1]
        return _iter

    def get_cuenta(self, _iter):
        cuenta = self.model.get_value(_iter, self.COL_OBJECT)
        return cuenta
        
    def on_lista_cuentas_row_activated(self, tree, path, column):
        _iter = self.model.get_iter(path)
        cuenta = self.get_cuenta(_iter)

        dialog = gtkDialogCuenta("Cuenta(%s)" % cuenta.nombre)
        cuenta = dialog.edit_cuenta(cuenta)
        # Al editar un contacto se crea uno nuevo y se elimina el antiguo
        if cuenta:
            self.update(_iter, cuenta)
            
    def on_lista_cuentas_button_press_event(self,  widget, event):
        if event.button == 3:
            gtkMenuContextual(event)

class gtkDialogCuenta:
    def __init__(self, title="Cuenta"):
        xml = gtk.glade.XML(FILE_GLADE, "dialog_cuenta")
        
        self.dialog = xml.get_widget("dialog_cuenta")
        self.dialog.set_transient_for(main.window.window)
        self.dialog.set_title(title)

        self.nombre = xml.get_widget("entry_cuenta_nombre")
        self.usuario = xml.get_widget("entry_cuenta_usuario")
        self.email = xml.get_widget("entry_cuenta_email")
        self.lugar = xml.get_widget("entry_lugar")
        self.clave = xml.get_widget("entry_clave")
        self.descripcion = xml.get_widget("entry_descripcion")
        
    def create_cuenta(self):
        newcuenta = None
        response = self.dialog.run()
        self.dialog.destroy()
        if response == gtk.RESPONSE_OK:
            newcuenta = self.get_form()
            # Agrego el nuevo contacto
            newcuenta.node = main.cuentas.append(newcuenta)
        return newcuenta
    
    def edit_cuenta(self, oldcuenta):
        self.set_form(oldcuenta)
        response = self.dialog.run()
        
        newcuenta = None
        if response == gtk.RESPONSE_OK:
            newcuenta = self.get_form()
            # Agrego la nueva cuenta y elimino la antigua
            newcuenta.node = main.cuentas.append(newcuenta)
            main.cuentas.remove(oldcuenta)            
        self.dialog.destroy()       
        return newcuenta 
    
    def set_form(self, cuenta):
        self.nombre.set_text(cuenta.nombre)
        self.lugar.set_text(cuenta.lugar)
        self.clave.set_text(cuenta.clave)
        self.usuario.set_text(cuenta.usuario)
        self.email.set_text(cuenta.email)
        self.descripcion.set_text(cuenta.descripcion)
        
    def get_form(self):
        cuenta = Cuenta()

        cuenta.nombre = self.nombre.get_text()
        cuenta.lugar = self.lugar.get_text()
        cuenta.usuario = self.usuario.get_text()
        cuenta.email = self.email.get_text()
        cuenta.clave = self.clave.get_text()
        cuenta.descripcion = self.descripcion.get_text()
        return cuenta
        
class gtkSearch(gladeInterfase):
    def __init__(self):
        self.entry_search = self.get_widget("entry_search")
        self.autoconnect()
                
    def get_text(self):
        return self.entry_search.get_text()

    def search(self, text):
        if main.selected == 'contactos':
            results = main.libreta.search(text)
            main.lista_contactos.populate(results)
        elif main.selected == 'cuentas':
            results = main.cuentas.search(text)
            main.lista_cuentas.populate(results)
   
    def on_entry_search_insert_text(self, editable, new_text,  
        new_text_length, position):
        text = self.get_text() + new_text
        self.search(text)

    def on_entry_search_delete_text(self, editable, start, end):
        text = self.get_text()[:start]
        self.search(text)

class gtkMenuContextual:
    def __init__(self, event):
        xml = gtk.glade.XML(FILE_GLADE, "menu_contextual")
        xml.signal_autoconnect(self)
        menu = xml.get_widget("menu_contextual")
        menu.popup(None, None, None, event.button, event.time)
        
    def on_item_nuevo_activate(*args):
        if main.selected == 'contactos':
            dialog = gtkDialogContacto(title='Contacto(Nuevo)')
            contacto = dialog.create_contacto()
            if contacto:
                main.lista_contactos.new(contacto)
        elif main.selected == 'cuentas':
            dialog = gtkDialogCuenta(title='Cuenta(Nuevo)')
            cuenta = dialog.create_cuenta()
            if cuenta:
                main.lista_cuentas.new(cuenta)
                
    def  on_item_borrar_activate(*args):
        if main.selected == 'contactos':
            main.lista_contactos.question_if_remove()
        elif main.selected == 'cuentas':
            main.lista_cuentas.question_if_remove()

    def on_item_propiedades_activate(*args):
        if main.selected == 'contactos':
            _iter = main.lista_contactos.get_row_selected()
            if _iter: 
                oldcontacto =  main.lista_contactos.get_contacto(_iter)
                dialog = gtkDialogContacto()
                contacto = dialog.edit_contacto(oldcontacto)
                if contacto:
                    main.lista_contactos.update(_iter, contacto)
        elif main.selected == 'cuentas':
            _iter = main.lista_cuentas.get_row_selected()
            if _iter: 
                oldcuenta =  main.lista_cuentas.get_cuenta(_iter)
                dialog = gtkDialogCuenta()
                cuenta = dialog.edit_cuenta(oldcuenta)
                if cuenta:
                    main.lista_cuentas.update(_iter, cuenta)
    
    
class gtkStatusBar(gladeInterfase):
    
    def __init__(self):
        self.status_bar = self.get_widget("status_bar")
        self.last_context = ""
        
    def set_message(self, message):
        if self.last_context:
            self.status_bar.pop(self.last_context)
        context_id = self.status_bar.get_context_id("context")
        self.status_bar.push(context_id, message)
        self.last_context = context_id


def gtkDialogSaveFile(title, suggested_name = ""):
    xml = gtk.glade.XML(FILE_GLADE, "dialog_file_save")
    dialog = xml.get_widget("dialog_file_save")
    dialog.set_title(title)
    dialog.set_transient_for(main.window.window)

    dialog.set_current_name(suggested_name)
    response = dialog.run()

    file= ""
    if response == gtk.RESPONSE_OK:
        file = dialog.get_filename()
    dialog.destroy()
    return file


class Main:
    selected = 'contactos'
    def __init__(self):
        gladeInterfase()
        self.window = gtkWindow()        

        self.libreta = Libreta(type='contactos')
        self.cuentas = Libreta(type='cuentas')
        self.lista_contactos = gtkListaContactos()
        self.lista_cuentas = gtkListaCuentas()
        self.search = gtkSearch()
        self.statusbar = gtkStatusBar()
        

main = Main()        
main.lista_contactos.populate()
main.lista_cuentas.populate()
gtk.main()
